home *** CD-ROM | disk | FTP | other *** search
/ Team Palmtops 7 / Palmtops_numero07.iso / WinCE / SDKWindowsCE / HandHeldPCPro30 / sdk.exe / Jupiter SDK / data1.cab / MFC / src / winfrmx.cpp < prev    next >
Encoding:
C/C++ Source or Header  |  1999-02-19  |  11.0 KB  |  428 lines
  1. // This is a part of the Microsoft Foundation Classes C++ library.
  2. // Copyright (C) 1992-1998 Microsoft Corporation
  3. // All rights reserved.
  4. //
  5. // This source code is only intended as a supplement to the
  6. // Microsoft Foundation Classes Reference and related
  7. // electronic documentation provided with the library.
  8. // See these sources for detailed information regarding the
  9. // Microsoft Foundation Classes product.
  10.  
  11. #include "stdafx.h"
  12.  
  13. #ifdef AFX_CORE3_SEG
  14. #pragma code_seg(AFX_CORE3_SEG)
  15. #endif
  16.  
  17. #ifdef _DEBUG
  18. #undef THIS_FILE
  19. static char THIS_FILE[] = __FILE__;
  20. #endif
  21.  
  22. /////////////////////////////////////////////////////////////////////////////
  23. // Basic Help support
  24.  
  25. #if defined(_WIN32_WCE)
  26. void CWnd::OnHelp()  // use context to derive help context 
  27. { 
  28.     // attempt to get help from whoever is tracking 
  29.     // just handle the main window case 
  30.     CWnd* pWnd = AfxGetMainWnd();
  31.     HWND hWnd = pWnd->GetSafeHwnd();
  32.     if (hWnd != NULL)
  33.     {
  34.         // attempt to process help
  35.         ::SendMessage(hWnd, WM_COMMANDHELP, 0, 0);
  36.         return;
  37.     }
  38.     // No context available, bring up default.
  39.     SendMessage(WM_COMMAND, ID_DEFAULT_HELP);
  40. }
  41. #else // _WIN32_WCE
  42. void CWnd::OnHelp()  // use context to derive help context
  43. {
  44.     // attempt to get help from whoever is tracking
  45.     HWND hWnd = ::GetCapture();
  46.     while (hWnd != NULL)
  47.     {
  48.         // attempt to process help
  49.         if (::SendMessage(hWnd, WM_COMMANDHELP, 0, 0))
  50.             return;
  51.  
  52.         // check next parent/owner in the parent/owner chain
  53.         hWnd = AfxGetParentOwner(hWnd);
  54.     }
  55.     // attempt to get help from whoever has the focus
  56.     hWnd = ::GetFocus();
  57.     while (hWnd != NULL)
  58.     {
  59.         // attempt to process help
  60.         if (::SendMessage(hWnd, WM_COMMANDHELP, 0, 0))
  61.             return;
  62.  
  63.         // check next parent/owner in the parent/owner chain
  64.         hWnd = AfxGetParentOwner(hWnd);
  65.     }
  66.     // attempt to get help from the active window
  67.     CWnd* pWnd = GetTopLevelParent();
  68.     hWnd = ::GetLastActivePopup(pWnd->GetSafeHwnd());
  69.     while (hWnd != NULL)
  70.     {
  71.         // attempt to process help
  72.         if (::SendMessage(hWnd, WM_COMMANDHELP, 0, 0))
  73.             return;
  74.  
  75.         // check next parent/owner in the parent/owner chain
  76.         hWnd = AfxGetParentOwner(hWnd);
  77.     }
  78.     // No context available, bring up default.
  79.     SendMessage(WM_COMMAND, ID_DEFAULT_HELP);
  80. }
  81. #endif // _WIN32_WCE
  82.  
  83. void CFrameWnd::OnHelp()
  84. {
  85.     // Be careful not call WinHelp when the error is failing to lauch help
  86.     if (m_dwPromptContext != 0)
  87.     {
  88.         if (m_dwPromptContext != HID_BASE_PROMPT+AFX_IDP_FAILED_TO_LAUNCH_HELP)
  89.             AfxGetApp()->WinHelp(m_dwPromptContext);
  90.         return;
  91.     }
  92.     CWnd::OnHelp();
  93. }
  94.  
  95. #if !defined(_WIN32_WCE)
  96. void CWnd::OnHelpIndex()
  97. {
  98.     AfxGetApp()->WinHelp(0L, HELP_INDEX);
  99. }
  100.  
  101. void CWnd::OnHelpFinder()
  102. {
  103.     AfxGetApp()->WinHelp(0L, HELP_FINDER);
  104. }
  105.  
  106. void CWnd::OnHelpUsing()
  107. {
  108.     AfxGetApp()->WinHelp(0L, HELP_HELPONHELP);
  109. }
  110. #endif // _WIN32_WCE
  111.  
  112. /////////////////////////////////////////////////////////////////////////////
  113. // Context Help Mode support
  114.  
  115. #if !defined(_WIN32_WCE)
  116. BOOL CFrameWnd::CanEnterHelpMode()
  117. {
  118.     ASSERT(m_bHelpMode != HELP_ACTIVE); // already in help mode?
  119.  
  120.     // unable to start help if the cursor cannot be loaded from the resources
  121.     if (afxData.hcurHelp == NULL)
  122.     {
  123.         afxData.hcurHelp = ::LoadCursor(NULL, IDC_HELP);
  124.         if (afxData.hcurHelp == NULL)
  125.         {
  126.             // load help cursor after handles have been setup
  127.             HINSTANCE hInst = AfxFindResourceHandle(
  128.                 MAKEINTRESOURCE(AFX_IDC_CONTEXTHELP), RT_GROUP_CURSOR);
  129.             afxData.hcurHelp = LoadCursor(hInst,
  130.                 MAKEINTRESOURCE(AFX_IDC_CONTEXTHELP));
  131.         }
  132.         if (afxData.hcurHelp == NULL)
  133.             return FALSE;
  134.     }
  135.  
  136.     // return TRUE if there is a handler for ID_CONTEXT_HELP
  137.     AFX_CMDHANDLERINFO info;
  138.     return OnCmdMsg(ID_CONTEXT_HELP, CN_COMMAND, NULL, &info);
  139. }
  140.  
  141. void CFrameWnd::OnContextHelp()
  142. {
  143.     // don't enter twice, and don't enter if initialization fails
  144.     if (m_bHelpMode == HELP_ACTIVE || !CanEnterHelpMode())
  145.         return;
  146.  
  147.     // don't enter help mode with pending WM_EXITHELPMODE message
  148.     MSG msg;
  149.     if (PeekMessage(&msg, m_hWnd, WM_EXITHELPMODE, WM_EXITHELPMODE,
  150.         PM_REMOVE|PM_NOYIELD))
  151.     {
  152.         return;
  153.     }
  154.  
  155.     BOOL bHelpMode = m_bHelpMode;
  156.     ASSERT(m_bHelpMode == HELP_INACTIVE || m_bHelpMode == HELP_ENTERING);
  157.     m_bHelpMode = HELP_ACTIVE;
  158.  
  159. #ifndef _AFX_NO_OLE_SUPPORT
  160.     // allow any in-place active servers to go into help mode
  161.     if (bHelpMode != HELP_ENTERING && m_pNotifyHook != NULL &&
  162.         !m_pNotifyHook->OnContextHelp(TRUE))
  163.     {
  164.         TRACE0("Error: an in-place server failed to enter context help mode.\n");
  165.         m_pNotifyHook->OnContextHelp(FALSE);    // undo partial help mode
  166.         m_bHelpMode = HELP_INACTIVE;
  167.         return;
  168.     }
  169. #endif
  170.  
  171.     if (bHelpMode == HELP_INACTIVE)
  172.     {
  173.         // need to delay help startup until later
  174.         PostMessage(WM_COMMAND, ID_CONTEXT_HELP);
  175.         m_bHelpMode = HELP_ENTERING;
  176.         return;
  177.     }
  178.  
  179.     ASSERT(m_bHelpMode == HELP_ACTIVE);
  180.  
  181.     // display special help mode message on status bar
  182.     UINT nMsgSave = (UINT)SendMessage(WM_SETMESSAGESTRING,
  183.         (WPARAM)AFX_IDS_HELPMODEMESSAGE);
  184.     if (nMsgSave == 0)
  185.         nMsgSave = AFX_IDS_IDLEMESSAGE;
  186.  
  187.     DWORD   dwContext = 0;
  188.     POINT   point;
  189.  
  190.     GetCursorPos(&point);
  191.     SetHelpCapture(point, NULL);
  192.     LONG lIdleCount = 0;
  193.     CWinApp* pApp = AfxGetApp();
  194.  
  195.     while (m_bHelpMode)
  196.     {
  197.         if (PeekMessage(&msg, NULL, 0, 0, PM_NOREMOVE))
  198.         {
  199.             if (!ProcessHelpMsg(msg, &dwContext))
  200.                 break;
  201.             ASSERT(dwContext == 0);
  202.         }
  203.         else if (!pApp->OnIdle(lIdleCount++))
  204.         {
  205.             lIdleCount = 0;
  206.             WaitMessage();
  207.         }
  208.     }
  209.  
  210.     m_bHelpMode = HELP_INACTIVE;
  211.     ReleaseCapture();
  212.  
  213.     // make sure the cursor is set appropriately
  214.     SetCapture();
  215.     ReleaseCapture();
  216.  
  217.     // restore original status bar text
  218.     SendMessage(WM_SETMESSAGESTRING, (WPARAM)nMsgSave);
  219.  
  220. #ifndef _AFX_NO_OLE_SUPPORT
  221.     // tell in-place servers to exit Shift+F1 help mode
  222.     if (m_pNotifyHook != NULL)
  223.         m_pNotifyHook->OnContextHelp(FALSE);
  224. #endif
  225.  
  226.     if (dwContext != 0)
  227.     {
  228.         if (dwContext == -1)
  229.             SendMessage(WM_COMMAND, ID_DEFAULT_HELP);
  230.         else
  231.             pApp->WinHelp(dwContext);
  232.     }
  233.     PostMessage(WM_KICKIDLE);    // trigger idle update
  234. }
  235.  
  236. /////////////////////////////////////////////////////////////////////////////
  237. // OnContextHelp helpers.
  238.  
  239. HWND CFrameWnd::SetHelpCapture(POINT point, BOOL* pbDescendant)
  240.     // set or release capture, depending on where the mouse is
  241.     // also assign the proper cursor to be displayed.
  242. {
  243.     if (!m_bHelpMode)
  244.         return NULL;
  245.  
  246.     HWND hWndCapture = ::GetCapture();
  247.     CWnd* pWndHit = WindowFromPoint(point);
  248.     HWND hWndHit = pWndHit->GetSafeHwnd();
  249.     CWnd* pTopHit = pWndHit->GetTopLevelParent();
  250.     CWnd* pTopActive = GetActiveWindow()->GetTopLevelParent();
  251.     BOOL bDescendant = FALSE;
  252.     HTASK hCurTask = (HTASK)GetCurrentThreadId();
  253.     HTASK hTaskHit = hWndHit != NULL ? ::GetWindowTask(hWndHit) : NULL;
  254.  
  255.     if (pTopActive == NULL || hWndHit == ::GetDesktopWindow())
  256.     {
  257.         if (hWndCapture == m_hWnd)
  258.             ReleaseCapture();
  259.         SetCursor(afxData.hcurArrow);
  260.     }
  261.     else if (pTopActive == NULL ||
  262.         hWndHit == NULL || hCurTask != hTaskHit ||
  263.         !AfxIsDescendant(m_hWnd, hWndHit))
  264.     {
  265.         if (hCurTask != hTaskHit)
  266.             hWndHit = NULL;
  267.         if (hWndCapture == m_hWnd)
  268.             ReleaseCapture();
  269.     }
  270.     else
  271.     {
  272.         bDescendant = TRUE;
  273.         if (pTopActive != pTopHit)
  274.             hWndHit = NULL;
  275.         else
  276.         {
  277.             if (hWndCapture != m_hWnd)
  278.                 ::SetCapture(m_hWnd);
  279.             SetCursor(afxData.hcurHelp);
  280.         }
  281.     }
  282.     if (pbDescendant != NULL)
  283.         *pbDescendant = bDescendant;
  284.     return hWndHit;
  285. }
  286.  
  287. AFX_STATIC DWORD AFXAPI _AfxMapClientArea(HWND hWnd, POINT point)
  288. {
  289.     DWORD dwContext;
  290.  
  291.     do
  292.     {
  293.         ASSERT(::IsWindow(hWnd));
  294.  
  295.         // check current window
  296.         ::ScreenToClient(hWnd, &point);
  297.         dwContext = ::SendMessage(hWnd, WM_HELPHITTEST, 0,
  298.             MAKELONG(point.x, point.y));
  299.         ::ClientToScreen(hWnd, &point);
  300.  
  301.         // don't use owner's of popup windows, just child/parent relationship
  302.         if ((GetWindowLong(hWnd, GWL_STYLE) & WS_CHILD) == 0)
  303.             break;
  304.         // check parent window
  305.         hWnd = ::GetParent(hWnd);
  306.     }
  307.     while (hWnd && dwContext == 0);
  308.  
  309.     return dwContext == 0 ? -1 : dwContext;
  310. }
  311.  
  312. AFX_STATIC DWORD AFXAPI _AfxMapNonClientArea(int iHit)
  313. {
  314.     ASSERT(iHit != HTCLIENT);
  315.  
  316.     if (iHit < 0 || iHit > HTHELP)
  317.         return (DWORD)-1;
  318.  
  319.     return HID_BASE_NCAREAS+iHit;
  320. }
  321.  
  322. BOOL CFrameWnd::ProcessHelpMsg(MSG& msg, DWORD* pContext)
  323. {
  324.     ASSERT(pContext != NULL);
  325.  
  326.     if (msg.message == WM_EXITHELPMODE ||
  327.         (msg.message == WM_KEYDOWN && msg.wParam == VK_ESCAPE))
  328.     {
  329.         PeekMessage(&msg, NULL, msg.message, msg.message, PM_REMOVE);
  330.         return FALSE;
  331.     }
  332.  
  333.     CPoint point;
  334.     if ((msg.message >= WM_MOUSEFIRST && msg.message <= WM_MOUSELAST) ||
  335.         (msg.message >= WM_NCMOUSEFIRST && msg.message <= WM_NCMOUSELAST))
  336.     {
  337.         BOOL bDescendant;
  338.         HWND hWndHit = SetHelpCapture(msg.pt, &bDescendant);
  339.         if (hWndHit == NULL)
  340.             return TRUE;
  341.  
  342.         if (bDescendant)
  343.         {
  344.             if (msg.message != WM_LBUTTONDOWN)
  345.             {
  346.                 // Hit one of our owned windows -- eat the message.
  347.                 PeekMessage(&msg, NULL, msg.message, msg.message, PM_REMOVE);
  348.                 return TRUE;
  349.             }
  350.             int iHit = (int)::SendMessage(hWndHit, WM_NCHITTEST, 0,
  351.                 MAKELONG(msg.pt.x, msg.pt.y));
  352.             if (iHit == HTMENU || iHit == HTSYSMENU)
  353.             {
  354.                 ASSERT(::GetCapture() == m_hWnd);
  355.                 ReleaseCapture();
  356.                 // the message we peeked changes into a non-client because
  357.                 // of the release capture.
  358.                 GetMessage(&msg, NULL, WM_NCLBUTTONDOWN, WM_NCLBUTTONDOWN);
  359.                 DispatchMessage(&msg);
  360.                 GetCursorPos(&point);
  361.                 SetHelpCapture(point, NULL);
  362.             }
  363.             else if (iHit == HTCLIENT)
  364.             {
  365.                 *pContext = _AfxMapClientArea(hWndHit, msg.pt);
  366.                 PeekMessage(&msg, NULL, msg.message, msg.message, PM_REMOVE);
  367.                 return FALSE;
  368.             }
  369.             else
  370.             {
  371.                 *pContext = _AfxMapNonClientArea(iHit);
  372.                 PeekMessage(&msg, NULL, msg.message, msg.message, PM_REMOVE);
  373.                 return FALSE;
  374.             }
  375.         }
  376.         else
  377.         {
  378.             // Hit one of our apps windows (or desktop) -- dispatch the message.
  379.             PeekMessage(&msg, NULL, msg.message, msg.message, PM_REMOVE);
  380.  
  381.             // Dispatch mouse messages that hit the desktop!
  382.             DispatchMessage(&msg);
  383.         }
  384.     }
  385.     else if (msg.message == WM_SYSCOMMAND ||
  386.              (msg.message >= WM_KEYFIRST && msg.message <= WM_KEYLAST))
  387.     {
  388.         if (::GetCapture() != NULL)
  389.         {
  390.             ReleaseCapture();
  391.             MSG msg;
  392.             while (PeekMessage(&msg, NULL, WM_MOUSEFIRST,
  393.                 WM_MOUSELAST, PM_REMOVE|PM_NOYIELD));
  394.         }
  395.         if (PeekMessage(&msg, NULL, msg.message, msg.message, PM_NOREMOVE))
  396.         {
  397.             GetMessage(&msg, NULL, msg.message, msg.message);
  398.             if (!PreTranslateMessage(&msg))
  399.             {
  400.                 TranslateMessage(&msg);
  401.                 if (msg.message == WM_SYSCOMMAND ||
  402.                   (msg.message >= WM_SYSKEYFIRST &&
  403.                     msg.message <= WM_SYSKEYLAST))
  404.                 {
  405.                     // only dispatch system keys and system commands
  406.                     ASSERT(msg.message == WM_SYSCOMMAND ||
  407.                          (msg.message >= WM_SYSKEYFIRST &&
  408.                           msg.message <= WM_SYSKEYLAST));
  409.                     DispatchMessage(&msg);
  410.                 }
  411.             }
  412.         }
  413.         GetCursorPos(&point);
  414.         SetHelpCapture(point, NULL);
  415.     }
  416.     else
  417.     {
  418.         // allow all other messages to go through (capture still set)
  419.         if (PeekMessage(&msg, NULL, msg.message, msg.message, PM_REMOVE))
  420.             DispatchMessage(&msg);
  421.     }
  422.  
  423.     return TRUE;
  424. }
  425. #endif // _WIN32_WCE
  426.  
  427. /////////////////////////////////////////////////////////////////////////////
  428.